home *** CD-ROM | disk | FTP | other *** search
/ The Fatted Calf / The Fatted Calf.iso / Modules / BackSpaceModules / Source / Neko / NekoView.m < prev    next >
Text File  |  1992-06-11  |  10KB  |  476 lines
  1.  
  2. #import "NekoView.h"
  3. #import "Thinker.h"
  4.  
  5. // based on xneko by Masayuki Koba
  6. // hacked into NeXTstep by Eric P. Scott
  7. // severely munged into BackSpace by sam streeper
  8. // go back to the X sources if you port this to other platforms...
  9.  
  10. #import <libc.h>
  11. #import <math.h>
  12. #import <defaults/defaults.h>
  13. #import <appkit/graphics.h>
  14. #import <appkit/Application.h>
  15. #import <appkit/Window.h>
  16. #import <appkit/NXImage.h>
  17. #import <dpsclient/wraps.h>
  18.  
  19. const NXCoord Even[]={
  20.     Mati2,    // STATE_STOP
  21.     Jare2,    // STATE_JARE
  22.     Kaki1,    // STATE_KAKI
  23.     Mati3,    // STATE_AKUBI
  24.     Sleep1,    // STATE_SLEEP
  25.     Awake,    // STATE_AWAKE
  26.     Up1,    // STATE_U_MOVE
  27.     Down1,    // STATE_D_MOVE
  28.     Left1,    // STATE_L_MOVE
  29.     Right1,    // STATE_R_MOVE
  30.     UpLeft1,    // STATE_UL_MOVE
  31.     UpRight1,    // STATE_UR_MOVE
  32.     DownLeft1,    // STATE_DL_MOVE
  33.     DownRight1,    // STATE_DR_MOVE
  34.     UpTogi1,    // STATE_U_TOGI
  35.     DownTogi1,    // STATE_D_TOGI
  36.     LeftTogi1,    // STATE_L_TOGI
  37.     RightTogi1    // STATE_R_TOGI
  38. };
  39.  
  40. const NXCoord Odd[]={
  41.     Mati2,    // STATE_STOP
  42.     Mati2,    // STATE_JARE
  43.     Kaki2,    // STATE_KAKI
  44.     Mati3,    // STATE_AKUBI
  45.     Sleep2,    // STATE_SLEEP
  46.     Awake,    // STATE_AWAKE
  47.     Up2,    // STATE_U_MOVE
  48.     Down2,    // STATE_D_MOVE
  49.     Left2,    // STATE_L_MOVE
  50.     Right2,    // STATE_R_MOVE
  51.     UpLeft2,    // STATE_UL_MOVE
  52.     UpRight2,    // STATE_UR_MOVE
  53.     DownLeft2,    // STATE_DL_MOVE
  54.     DownRight2,    // STATE_DR_MOVE
  55.     UpTogi2,    // STATE_U_TOGI
  56.     DownTogi2,    // STATE_D_TOGI
  57.     LeftTogi2,    // STATE_L_TOGI
  58.     RightTogi2    // STATE_R_TOGI
  59. };
  60.  
  61. #define    PI_PER8            ((double)M_PI/(double)8)
  62. double    SinPiPer8Times3;
  63. double    SinPiPer8;
  64.  
  65. @implementation NekoView
  66.  
  67. - TickCount
  68. {
  69.     if ( ++NekoTickCount >= MAX_TICK )
  70.         NekoTickCount = 0;
  71.  
  72.     if ( NekoTickCount % 2 == 0 )
  73.         if ( NekoStateCount < MAX_TICK )
  74.             NekoStateCount++;
  75.  
  76.     return self;
  77. }
  78.  
  79. - SetNekoState: (int) SetValue
  80. {
  81.     NekoTickCount=0;
  82.     NekoStateCount=0;
  83.  
  84.     NekoState=SetValue;
  85.     return self;
  86. }
  87.  
  88. - DrawNeko: (NXCoord) DrawIcon
  89. { 
  90.     NekoLastIcon.origin.x=DrawIcon;
  91.  
  92.     if (NX_X(&NekoPos) != NekoLastXY.x || NX_Y(&NekoPos)!=NekoLastXY.y)
  93.     {
  94.         static const NXRect zero={ { Space, 0.0 },
  95.             { (NXCoord)BITMAP_WIDTH, (NXCoord)BITMAP_HEIGHT } };
  96.  
  97.         [bitmaps composite:NX_SOVER fromRect:&zero toPoint:&NekoLastXY];        
  98.     }
  99.  
  100.     [bitmaps composite:NX_SOVER fromRect:&NekoLastIcon
  101.         toPoint:&NekoPos.origin];
  102.  
  103.     NekoLastXY=NekoPos.origin;
  104.     return self;
  105. }
  106.  
  107. - NekoDirection
  108. {
  109.     int            NewState;
  110.     double        LargeX, LargeY;
  111.     double        Length;
  112.     double        SinTheta;
  113.  
  114.     if ( NekoMoveDx == 0 && NekoMoveDy == 0 )
  115.         NewState = STATE_STOP;
  116.     else
  117.     {
  118.     LargeX = (double)NekoMoveDx;
  119.     LargeY = (double)(-NekoMoveDy);
  120.     Length = sqrt( LargeX * LargeX + LargeY * LargeY );
  121.     SinTheta = LargeY / Length;
  122.  
  123.     if ( NekoMoveDx > 0 )
  124.     {
  125.         if ( SinTheta > SinPiPer8Times3 )
  126.             NewState = STATE_U_MOVE;
  127.         else if ((SinTheta <= SinPiPer8Times3) && (SinTheta > SinPiPer8))
  128.             NewState = STATE_UR_MOVE;
  129.         else if ((SinTheta <= SinPiPer8) && (SinTheta > -(SinPiPer8)))
  130.             NewState = STATE_R_MOVE;
  131.         else if ((SinTheta <= -SinPiPer8) && (SinTheta > -SinPiPer8Times3))
  132.             NewState = STATE_DR_MOVE;
  133.         else
  134.             NewState = STATE_D_MOVE;
  135.     }
  136.     else
  137.     {
  138.         if ( SinTheta > SinPiPer8Times3)
  139.             NewState = STATE_U_MOVE;
  140.         else if ((SinTheta <= SinPiPer8Times3) && (SinTheta > SinPiPer8))
  141.             NewState = STATE_UL_MOVE;
  142.         else if ((SinTheta <= SinPiPer8 ) && (SinTheta > -SinPiPer8))
  143.             NewState = STATE_L_MOVE;
  144.         else if ((SinTheta <= -SinPiPer8) && (SinTheta > -SinPiPer8Times3))
  145.             NewState = STATE_DL_MOVE;
  146.         else
  147.             NewState = STATE_D_MOVE;
  148.     }
  149.     }
  150.  
  151.     if ( NekoState != NewState )
  152.         [self SetNekoState: NewState];
  153.  
  154.     return self;
  155. }
  156.  
  157. - (BOOL) IsNekoDontMove
  158. {
  159.     if ( NX_X(&NekoPos) == NekoLastXY.x && NX_Y(&NekoPos) == NekoLastXY.y )
  160.         return( YES );
  161.  
  162.     return( NO );
  163. }
  164.  
  165. - (BOOL) IsNekoMoveStart
  166. {
  167.     if ( ( PrevMouseX >= MouseX - IDLE_SPACE
  168.             && PrevMouseX <= MouseX + IDLE_SPACE ) &&
  169.             ( PrevMouseY >= MouseY - IDLE_SPACE 
  170.             && PrevMouseY <= MouseY + IDLE_SPACE ) )
  171.         return( NO );
  172.  
  173.     return( YES );
  174. }
  175.  
  176. - CalcDxDy
  177. {
  178.     double    LargeX, LargeY;
  179.     double    DoubleLength, Length;
  180.  
  181.     if (randCount1 == -100)        // a signal to let values be...
  182.         randCount1 = 200;
  183.     else
  184.     {
  185.           PrevMouseX = MouseX;
  186.         PrevMouseY = MouseY;
  187.     }
  188.  
  189.     if (--randCount1 < 0)
  190.     {
  191.         randCount1 = (random() % (300));
  192.         MouseX = randBetween(-90,bounds.size.width+90);
  193.         MouseY = randBetween(-90,bounds.size.height+90);
  194.     }
  195.  
  196.     LargeX = (double)( MouseX - NX_X(&NekoPos) - BITMAP_WIDTH/2 );
  197.     LargeY = (double)( MouseY - NX_Y(&NekoPos));
  198.  
  199.     DoubleLength = LargeX * LargeX + LargeY * LargeY;
  200.  
  201.     if ( DoubleLength != (double)0 )
  202.     {
  203.         Length = sqrt( DoubleLength );
  204.         if ( Length <= NekoSpeed ) {
  205.             NekoMoveDx = (int)LargeX;
  206.             NekoMoveDy = (int)LargeY;
  207.         } else {
  208.             NekoMoveDx = (int)( ( NekoSpeed * LargeX ) / Length );
  209.             NekoMoveDy = (int)( ( NekoSpeed * LargeY ) / Length );
  210.         }
  211.     }
  212.     else NekoMoveDx = NekoMoveDy = 0;
  213.  
  214.     return self;
  215. }
  216.  
  217.  
  218. - oneStep
  219. {
  220.     usleep(1000000 / 8);    // run at about 8 frames/sec
  221.  
  222.     [self CalcDxDy];
  223.  
  224.     if ( NekoState != STATE_SLEEP )
  225.         [self DrawNeko: NekoTickCount % 2 == 0 ?
  226.             Even[NekoState] : Odd[NekoState]];
  227.     else [self DrawNeko: NekoTickCount % 8 <= 3 ?
  228.             Even[NekoState] :Odd[NekoState]];
  229.  
  230.     [self TickCount];
  231.  
  232.     switch ( NekoState ) 
  233.     {
  234.     case STATE_STOP:
  235.         if ( [self IsNekoMoveStart])
  236.         {
  237.             [self SetNekoState: STATE_AWAKE ];
  238.             break;
  239.         }
  240.         if ( NekoStateCount < TIME_STOP )
  241.             break;
  242.  
  243.         if ( NekoMoveDx < 0 && NX_X(&NekoPos) <= 0 )
  244.             [self SetNekoState: STATE_L_TOGI ];
  245.  
  246.         else if ( NekoMoveDx > 0 &&
  247.                 NX_X(&NekoPos) >= NX_WIDTH(&bounds) - BITMAP_WIDTH )
  248.             [self SetNekoState: STATE_R_TOGI ];
  249.  
  250.         else if ( NekoMoveDy < 0 && NX_Y(&NekoPos) <= 0 )
  251.             [self SetNekoState: STATE_U_TOGI ];
  252.  
  253.         else if ( NekoMoveDy > 0 && NX_Y(&NekoPos) >=
  254.                 NX_HEIGHT(&bounds) - BITMAP_HEIGHT )
  255.             [self SetNekoState: STATE_D_TOGI ];
  256.  
  257.         else [self SetNekoState: STATE_JARE ];
  258.  
  259.         break;
  260.  
  261.     case STATE_JARE:
  262.         if ( [self IsNekoMoveStart] )
  263.         {
  264.             [self SetNekoState: STATE_AWAKE ];
  265.             break;
  266.         }
  267.         if ( NekoStateCount < TIME_JARE )
  268.             break;
  269.  
  270.         [self SetNekoState: STATE_KAKI ];
  271.         break;
  272.  
  273.     case STATE_KAKI:
  274.         if ( [self IsNekoMoveStart])
  275.         {
  276.             [self SetNekoState: STATE_AWAKE ];
  277.             break;
  278.         }
  279.         if ( NekoStateCount < TIME_KAKI )
  280.             break;
  281.  
  282.         [self SetNekoState: STATE_AKUBI ];
  283.         break;
  284.  
  285.     case STATE_AKUBI:
  286.         if ( [self IsNekoMoveStart] )
  287.         {
  288.             [self SetNekoState: STATE_AWAKE ];
  289.             break;
  290.         }
  291.         if ( NekoStateCount < TIME_AKUBI )
  292.             break;
  293.  
  294.         [self SetNekoState: STATE_SLEEP ];
  295.         break;
  296.  
  297.     case STATE_SLEEP:
  298.         if ( [self IsNekoMoveStart] )
  299.         {
  300.             [self SetNekoState: STATE_AWAKE ];
  301.             break;
  302.         }
  303.         break;
  304.  
  305.     case STATE_AWAKE:
  306.         if ( NekoStateCount < TIME_AWAKE )
  307.             break;
  308.  
  309.         [self NekoDirection];
  310.         break;
  311.  
  312.     case STATE_U_MOVE:
  313.     case STATE_D_MOVE:
  314.     case STATE_L_MOVE:
  315.     case STATE_R_MOVE:
  316.     case STATE_UL_MOVE:
  317.     case STATE_UR_MOVE:
  318.     case STATE_DL_MOVE:
  319.     case STATE_DR_MOVE:
  320.         NekoPos.origin.x += NekoMoveDx;
  321.         NekoPos.origin.y += NekoMoveDy;
  322.         [self NekoDirection];
  323.         [self NekoAdjust];
  324.  
  325.         if ( [self IsNekoDontMove])
  326.             [self SetNekoState: STATE_STOP ];
  327.  
  328.         break;
  329.  
  330.     case STATE_U_TOGI:
  331.     case STATE_D_TOGI:
  332.     case STATE_L_TOGI:
  333.     case STATE_R_TOGI:
  334.         if ( [self IsNekoMoveStart] )
  335.         {
  336.             [self SetNekoState: STATE_AWAKE ];
  337.             break;
  338.         }
  339.         if ( NekoStateCount < TIME_TOGI )
  340.             break;
  341.  
  342.         [self SetNekoState: STATE_KAKI ];
  343.         break;
  344.  
  345.     default:
  346.         /* Internal Error */
  347.         [self SetNekoState: STATE_STOP ];
  348.         break;
  349.     }
  350.  
  351.     return self;
  352. }
  353.  
  354. - NekoAdjust
  355. {
  356.     if ( NX_X(&NekoPos) < 0 )
  357.         NekoPos.origin.x = 0;
  358.     else if ( NX_X(&NekoPos) > NX_WIDTH(&bounds) - BITMAP_WIDTH )
  359.         NekoPos.origin.x = NX_WIDTH(&bounds) - BITMAP_WIDTH;
  360.  
  361.     if ( NX_Y(&NekoPos) < 0 )
  362.         NekoPos.origin.y = 0;
  363.     else if ( NX_Y(&NekoPos) > NX_HEIGHT(&bounds) - BITMAP_HEIGHT )
  364.         NekoPos.origin.y = NX_HEIGHT(&bounds) - BITMAP_HEIGHT;
  365.  
  366.     return self;
  367. }
  368.  
  369. - setBitmaps:anObject
  370. {
  371.     bitmaps = anObject;
  372.     return self;
  373. }
  374.  
  375. - bitmaps
  376. {
  377.     return bitmaps;
  378. }
  379.  
  380. - initFrame:(const NXRect *)frameRect
  381. {
  382.     SinPiPer8Times3=sin(PI_PER8*(double)3);
  383.     SinPiPer8=sin(PI_PER8);
  384.  
  385.     [super initFrame:frameRect];
  386.     [self setClipping:NO];
  387.     [self allocateGState];
  388.  
  389.     NXSetRect(&NekoPos,
  390.         (NX_WIDTH(frameRect)-(NXCoord)(BITMAP_WIDTH/2))/2.0,
  391.         (NX_HEIGHT(frameRect)-(NXCoord)(BITMAP_HEIGHT/2))/2.0,
  392.         (NXCoord)BITMAP_WIDTH, (NXCoord)BITMAP_HEIGHT);
  393.     NekoLastXY=NekoPos.origin;
  394.  
  395.     bitmaps=[self findImageNamed:"browncat"];
  396.  
  397.     NXSetRect(&NekoLastIcon, Even[STATE_STOP], 0.0,
  398.         (NXCoord)BITMAP_WIDTH, (NXCoord)BITMAP_HEIGHT);
  399.     NekoSpeed=14;
  400.     [self SetNekoState: STATE_STOP];
  401.     randCount1 = 100;
  402.     return self;
  403. }
  404.  
  405. - drawSelf:(const NXRect *)rects :(int)rectCount
  406. {
  407.     if (!rects || !rectCount) return self;
  408.     PSsetgray(0);
  409.     NXRectFill(rects);
  410.  
  411.     [bitmaps composite:NX_SOVER fromRect:&NekoLastIcon
  412.         toPoint:&NekoPos.origin];
  413.  
  414.     return self;
  415. }
  416.  
  417. - sizeTo:(NXCoord)width :(NXCoord)height
  418. {
  419.     [super sizeTo:width:height];
  420.     [self NekoAdjust];
  421.     return self;
  422. }
  423.  
  424. - (const char *) windowTitle
  425. {    return "Neko";
  426. }
  427.  
  428. - inspector:sender
  429. {
  430.     char buf[MAXPATHLEN];
  431.     
  432.     if (!inspectorPanel)
  433.     {
  434.         sprintf(buf,"%s/Neko.nib",[sender moduleDirectory:"Neko"]);
  435.         [NXApp loadNibFile:buf owner:self withNames:NO];
  436.     }
  437.     return inspectorPanel;
  438. }
  439.  
  440. - (BOOL) useBufferedWindow
  441. {    return YES;
  442. }
  443.  
  444. - findImageNamed:(const char *)name
  445. {
  446.     char buf[1024];
  447.     id ret = [NXImage findImageNamed:name];
  448.     if (ret) return ret;
  449.  
  450.     sprintf(buf,"%s/%s.tiff",[(BSThinker()) moduleDirectory:"Neko"],name);
  451.     ret = [[NXImage alloc] initFromFile:buf];
  452.     [ret setName:name];
  453.     return ret;
  454. }
  455.  
  456. - inspectorWillBeRemoved
  457. {
  458.     [infoWindow orderOut:self];
  459.     return self;
  460. }
  461.  
  462. - mouseDown:(NXEvent *)event
  463. {
  464.     NXPoint loc = event->location;
  465.     [self convertPoint:&loc fromView:nil];
  466.     randCount1 = -100;
  467.       PrevMouseX = MouseX;
  468.     PrevMouseY = MouseY;
  469.     MouseX = loc.x;
  470.     MouseY = loc.y;
  471.     return self;
  472. }
  473.  
  474.  
  475. @end
  476.